package com.yeqiangwei.commons.util;

import java.util.List;
import java.util.StringTokenizer;
import java.util.regex.Pattern;

public class Utils {

	public static void main(String args[]) {
		System.out.println(Utils.isChar("薛海泉"));
		System.out.println(Utils.isChar("xuehai quan"));
		System.out.println(Utils.isLetter("xuehaiquan"));
		System.out.println(Utils.isChar("xue海泉"));
	}

	/**
	 * 指定范围的随机数
	 * 
	 * @param begin
	 * @param end
	 * @return
	 */
	public static Long getRandomNumber(int begin, int end) {
		return Math.round(Math.random() * (end - begin) + begin);
	}

	/**
	 * 判断字符是否为空
	 * 
	 * @param str
	 * @return boolean
	 */
	public static boolean isNull(String str) {
		if (str != null && str.length() > 0) {
			return false;
		}
		return true;
	}
	
	public static boolean isNull(List<?> l){
		return null == l || l.size() <= 0 ? true : false;
	}
	/**
	 * 判断对象是否为空
	 * @param obj
	 * @return
	 */
	public static boolean isNull(Object obj){
		return null == obj ? true : false;
	}

	/**
	 * 判断对象是否为空
	 * 
	 * @param obj
	 * @return boolean
	 */
	public static boolean isNull(Object[] obj) {
		if (obj != null && obj.length > 0) {
			return false;
		}
		return true;
	}

	/**
	 * 转换为整型
	 * 
	 * @param 保留值
	 *            -999,返回-999表示不是数字
	 */
	public static int isDigits(String str) {
		if (isNull(str))
			return -999;
		try {
			return new Integer(str).intValue();
		} catch (NumberFormatException e) {
			return -999;
		}
	}

	/**
	 * 判断是否为数字组成的字串
	 * 
	 * @param validString
	 *            要判断的字符串
	 * @return boolen值，true或false
	 */
	public static boolean isNumber(String validString) {
		if (validString == null || validString.length() < 1) {
			return false;
		} else {
			byte[] tempbyte = validString.getBytes();
			for (int i = 0; i < validString.length(); i++) {
				// by=tempbyte;
				if ((tempbyte[i] == 45) && (i == 0)) {
					continue;
				}
				if ((tempbyte[i] < 48) || (tempbyte[i] > 57)) {
					return false;
				}
			}
			return true;
		}
	}

	/**
	 * 判断是否为数字及最多一个小数点组成的实型数
	 * 
	 * @param validString
	 *            要判断的字符串
	 * @return boolen值，true或false
	 */
	public static boolean isReal(String validString) {
		byte[] tempbyte = validString.getBytes();

		// 0~9的个数
		int a = 0;
		// 小数点的个数
		int b = 0;
		// 其他字符
		int c = 0;
		// 符号
		int d = 0;

		for (int i = 0; i < validString.length(); i++) {
			if ((tempbyte[i] == 45) && (i == 0)) {
				d++;
				continue;
			}
			if ((tempbyte[i] >= 48) && (tempbyte[i] <= 57)) {
				a++;
				continue;
			}
			// 这是小数点
			if (tempbyte[i] == 46) {
				b++;
				continue;
			}
			c++;
		}
		if (c > 0 || b > 1) {
			return false;
		}
		return true;
	}

	/**
	 * 判断是否为允许有,号的货币弄字符串
	 * 
	 * @param validString
	 *            要判断的字符串
	 * @return boolen值，true或false
	 */
	public static boolean isMoney(String validString) {
		if (isNull(validString))
			return false;
		else
			validString = validString.replaceAll(",", "");
		validString = validString.replaceAll("-", "");
		if (isReal(validString))
			return true;
		else
			return false;
	}

	/**
	 * 判断是否符合指定长度条件
	 * 
	 * @param validString
	 *            要判断的字符串
	 * @long1 最小长度
	 * @long2 最大长度
	 * @return boolen值，true或false
	 */
	public static boolean isLong(String validString, int long1, int long2) {
		if (validString.length() > (long2 + 1) || validString.length() < (long1 + 1)) {
			return false;
			// 字符串的长度有误
		}
		return true;
	}

	/**
	 * 判断字符串是否为只包括字母和数字
	 * 
	 * @param validString
	 *            要判断的字符串
	 * @return boolen值，true或false
	 */
	public static boolean isChar(String validString) {
		byte[] tempbyte = validString.getBytes();
		for (int i = 0; i < validString.length(); i++) {
			// by=tempbyte;
			if ((tempbyte[i] < 48) || ((tempbyte[i] > 57) & (tempbyte[i] < 65)) || (tempbyte[i] > 122) || ((tempbyte[i] > 90) & (tempbyte[i] < 97))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 判断字符串是否只包括字母
	 * 
	 * @param validString
	 *            要判断的字符串
	 * @return boolen值，true或false
	 */
	public static boolean isLetter(String validString) {
		byte[] tempbyte = validString.getBytes();
		for (int i = 0; i < validString.length(); i++) {
			if ((tempbyte[i] < 65) || (tempbyte[i] > 122) || ((tempbyte[i] > 90) & (tempbyte[i] < 97))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 判断是否为合法的时间字符串
	 * 
	 * @param DATESTR
	 * @return boolean
	 */
	public static boolean isDate(String DATESTR) {
		boolean b = false;
		if (!isNull(DATESTR)) {
			try {
				b = java.text.DateFormat.getDateInstance().parse(DATESTR) != null;
			} catch (java.text.ParseException e) {
				b = false;
			}
		}
		return b;
	}

	/**
	 * 检测email地址是否合法
	 * 
	 * @param smail
	 * @return boolean
	 */
	public static boolean isMail(String smail) {
		if (ValidatorHelper.isEmpty(smail)) {
			return false;
		} 
		boolean b = true;
		String end = StringHelper.substring(smail, smail.length() - 1, smail.length(), "");
		if(!Utils.isLetter(end)){
			return false;
		}
		else {
			int point = smail.indexOf("@");
			if (point < 1)
				return false;
			String temp1 = smail.substring(0, point);
			String temp2 = smail.substring(point + 1);
			if (temp1.indexOf(".") == -1) {
				b = true;
			}
			if (temp2.indexOf(".") == -1) {
				b = false;
			} else {
				if (temp2.length() - temp2.lastIndexOf(".") > 5) {
					b = false;
				}
			}
		}
		return b;
	}

	/**
	 * 判断字符串是否含有中文
	 * 
	 * @param validString
	 *            要判断的字符串
	 * @return boolen值，true或false
	 */
	public static boolean isCompriseGBK(String str) {
		// str = "中国chinese";
		str = getstr(str);
		boolean temp = false;
		for (int i = 0; i < str.length(); i++) {
			if (str.substring(i, i + 1).matches("[\\u4e00-\\u9fa5]+")) {
				temp = true;
				break;
			}
		}

		return temp;
	}

	/**
	 * 检测是否为合法的电话号码
	 * 
	 * @param num
	 * @return boolean
	 */
	public static boolean isPhoneNumber(String num) {
		return Pattern.matches("(\\(\\d{3}\\)|\\d{3,4}-)?\\d{7,8}$", num);
	}

	/**
	 * 检测是否为合法的手机号码
	 * 
	 * @param num
	 * @return boolean
	 */
	public static boolean isMobileNumber(String num) {
		return Pattern.matches("0?1[358]\\d{9}", num);
	}

	/**
	 * 检测是否为合法的邮编
	 * 
	 * @param num
	 * @return boolean
	 */
	public static boolean isZipCodeNumber(String num) {
		return Pattern.matches("\\d{6}", num);
	}

	/*
	 * 2005新写字符判断函数
	 */

	/**
	 * @author Jacky wu Date 2005-1-29
	 * @param 取文件扩展名
	 * @param String
	 *            fileName 文件名全称
	 * @return String 文件扩展名
	 */
	public static String getFileName(String fileName) {
		String tempName = "";
		if (fileName != null) {
			// 取文件名中最后一个.的位置
			int pos = fileName.lastIndexOf(".");
			// 取pos后的字符串
			tempName = fileName.substring(pos + 1, fileName.length());
		}
		return tempName;
	}

	/**
	 * @author Jacky wu Date 2005-1-29
	 * @param 检测文件类型
	 * @param String
	 *            fileName 要检测文件名
	 * @param String
	 *            [] files 允许的文件后缀
	 * @return boolean True表示为允许文件类别
	 */
	public static boolean isFileType(String fileName, String[] files) {
		boolean b = false;
		if (fileName != null && files.length > 0) {
			String tempName = getFileName(fileName);
			// System.out.println(tempName);
			for (int i = 0; i < files.length; i++) {
				if (files.equals(tempName)) {
					b = true;
					break;
				}
			}
		}
		return b;
	}

	/**
	 * 将表单中文或者浏览中文转换为GBK格式
	 * 
	 * @param str
	 * @return String
	 */
	public static String getstr(String str) {
		try {
			String temp_p = str.trim();
			byte[] temp_t = temp_p.getBytes("ISO8859-1");
			String temp = new String(temp_t);
			return temp;
		} catch (Exception e) {
			e.printStackTrace();
			return "";
		}
	}

	/**
	 * 将数据库中文转换为GBK格式
	 * 
	 * @param str
	 * @return String
	 */
	public static String getDBstr(String str) {
		try {
			String temp_p = str;
			String temp = new String(temp_p.getBytes("GBK"), "ISO8859_1");
			return temp;
		} catch (Exception e) {
			return "";
		}
	}

	/**
	 * 从数据库中得到字符串用于在网页控件中还原显示
	 * 
	 * @param str
	 * @return String
	 */
	public static String getSafeStrToHtml(String str) {
		try {
			// String theStr = this.getDBstr(str);
			String theStr = str;
			theStr = theStr.replaceAll("&#39", "'");
			theStr = theStr.replaceAll("&lt;", "<");
			theStr = theStr.replaceAll("&gt;", ">");
			theStr = theStr.replaceAll("<br>", "\n");
			// theStr = theStr.replaceAll("&nbsp", " ");
			return theStr;
		} catch (Exception e) {
			return "";
		}
	}

	/**
	 * 从多行文本框内容转换为Sql安全字符串
	 * 
	 * @param str
	 * @return String
	 */
	public static String getSafeStrToDB(String str) {
		try {
			// String theStr = this.getDBstr(str);
			String theStr = str;
			theStr = theStr.replaceAll("'", "&#39");
			theStr = theStr.replaceAll("<", "&lt;");
			theStr = theStr.replaceAll(">", "&gt;");
			theStr = theStr.replaceAll("\n", "<br>");
			// theStr = theStr.replaceAll(" ", "&nbsp");
			// theStr = theStr.replaceAll("; ;", " ");
			return theStr;
		} catch (Exception e) {
			return "";
		}
	}

	/**
	 * 从多行文本框内容转换为Sql安全字符串,同时将中文的编码转换为GBK格式
	 * 
	 * @param str
	 * @return
	 */
	public static String getSafeStrToDBAndGBK(String str) {
		str = getstr(str);
		str = getSafeStrToDB(str);
		return str;
	}

	/**
	 * 获取IP地址前三位
	 * 
	 * @param ip
	 * @return String
	 */
	public static String getPart(String ip) {
		int pos = ip.lastIndexOf(".");
		ip = ip.substring(0, pos) + ".*";
		return ip;
	}

	/**
	 * 获取一个字符串的绝对长度(如果遇到汉字字符则算两个)
	 * 
	 * @param s
	 *            传入的字串
	 * @param return 字串的绝对长度
	 */
	public static int absoluteLength(String s) {
		if (s == null) {
			return 0;
		}
		try {
			return new String(s.getBytes("GB2312"), "ISO8859_1").length();
		} catch (Exception e) {
			return s.length();
		}
	}

	/**
	 * 将字符串分割为数组
	 * 
	 * @param str
	 *            要转换的字符串
	 * @param f
	 *            分割字符
	 * @return String[]
	 */
	public static String[] splite(String str, String f) {
		StringTokenizer a = new StringTokenizer(str, f);
		int i = 0;
		String[] strs = new String[a.countTokens()];
		if (a.countTokens() > 0) {
			try {
				while (a.hasMoreTokens()) {
					strs[i] = a.nextToken();
					i++;
				}
			} catch (ArrayIndexOutOfBoundsException e) {
				System.out.println("数组越界");
			}

		}
		return strs;
	}

	/**
	 * 将输入的数组转换为字符串
	 * 
	 * @param array
	 *            传入数组
	 * @param f
	 *            分割串
	 * @return
	 */
	public static String spliteToString(String[] array, String f) {
		String strs = new String();
		for (int i = 0; i < array.length; i++) {
			// System.out.println(array);
			if (i < array.length - 1) {
				strs += array + f;
			} else {
				strs += array;
			}
		}
		return strs;
	}

	/**
	 * 对一个字符串的绝对长度进行拆解(如果遇到汉字字符会把它当作两个字符处理)
	 * 
	 * @param s
	 *            传入的字串
	 * @param start
	 *            起始绝对位置
	 * @param end
	 *            终止绝对位置
	 * @param endStr
	 *            尾部省略字符,如"...",不需要则留空
	 * @return 返回的字串
	 */
	public static String absoluteSubstring(String s, int start, int end, String endStr) {

		if (s == null) {
			return null;
		}
		try {
			String s2 = new String(s.getBytes("GB2312"), "ISO8859_1");
			String e2 = new String(endStr.getBytes("GB2312"), "ISO8859_1");

			if (end >= s2.length()) {
				end = s2.length();
				endStr = "";
			} else if (!"".equals(e2) && e2 != null) {
				int num = end - start; // 定义需要的长度
				end = num - e2.length();
			}

			s2 = s2.substring(start, end);
			return new String(s2.getBytes("ISO8859_1"), "GB2312") + endStr;
		} catch (Exception e) {
			return s.substring(start, end);
		}
	}

	/**
	 * 扩充一个字串，使其绝对长度为指定的长度，如果过长就截断，过短就补充指定的字串
	 * 
	 * @param str
	 *            传入的字串
	 * @param updateStr
	 *            填充的字串
	 * @param num
	 *            指定的长度
	 * @param flag
	 *            填补字符串的位置：true的话在前面填补、false在后面填补
	 * @return 返回的字串
	 */
	public static String updateAbsoluteLength(String str, String updateStr, int num, boolean flag) {
		if (updateStr == null) {
			return str;
		}
		if (str == null) {
			str = "";
			for (int i = 0; i < num; i++) {
				str += updateStr;
			}
			return str;
		}
		if (absoluteLength(str) == num) {
			return str;
		} else if (absoluteLength(str) < num) {
			for (int i = absoluteLength(str); i < num; i++) {
				if (flag) {
					str = updateStr + str;
				} else {
					str = str + updateStr;
				}
			}
			return str;
		} else {
			return absoluteSubstring(str, 0, absoluteLength(str) - num, "");
		}
	}

}
